 /*******************************************************************************
  * Copyright (c) 2005, 2006 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.core.commands.operations;

 import org.eclipse.core.runtime.IStatus;

 /**
  * <p>
  * OperationHistoryEvent is used to communicate changes that occur in a
  * DefaultOperationHistory, including the addition or removal of operations, and
  * the execution, undo, and redo of operations.
  * </p>
  * <p>
  * Operation history listeners must be prepared to receive notifications from a
  * background thread. Any UI access occurring inside the implementation must be
  * properly synchronized using the techniques specified by the client's widget
  * library.
  * </p>
  *
  *
  * @since 3.1
  */
 public final class OperationHistoryEvent {

     /**
      * ABOUT_TO_EXECUTE indicates that an operation is about to execute.
      * Listeners should prepare for the execution as appropriate. Listeners will
      * receive a DONE notification if the operation is successful, or an
      * OPERATION_NOT_OK notification if the execution is cancelled or otherwise
      * fails. This notification is only received for those operations executed
      * by the operation history. Operations that are added to the history after
      * execution do not trigger these notifications.
      *
      * If the operation successfully executes, clients will also receive a
      * notification that it has been added to the history.
      *
      * (value is 1).
      */

     public static final int ABOUT_TO_EXECUTE = 1;

     /**
      * ABOUT_TO_REDO indicates that an operation is about to be redone.
      * Listeners should prepare for the redo as appropriate. Listeners will
      * receive a REDONE notification if the operation is successful, or an
      * OPERATION_NOT_OK notification if the redo is cancelled or otherwise
      * fails.
      *
      * (value is 2).
      */
     public static final int ABOUT_TO_REDO = 2;

     /**
      * ABOUT_TO_UNDO indicates that an operation is about to be undone.
      * Listeners should prepare for the undo as appropriate. Listeners will
      * receive an UNDONE notification if the operation is successful, or an
      * OPERATION_NOT_OK notification if the undo is cancelled or otherwise
      * fails.
      *
      * (value is 3).
      */
     public static final int ABOUT_TO_UNDO = 3;

     /**
      * DONE indicates that an operation has been executed. Listeners can take
      * appropriate action, such as revealing any relevant state in the UI. This
      * notification is only received for those operations executed by the
      * operation history. Operations that are added to the history after
      * execution do not trigger this notification.
      *
      * Clients will also receive a notification that the operation has been
      * added to the history.
      *
      * (value is 4).
      */
     public static final int DONE = 4;

     /**
      * OPERATION_ADDED indicates that an operation was added to the history.
      * Listeners can use this notification to add their undo context to a new
      * operation as appropriate or otherwise record the operation.
      *
      * (value is 5).
      */
     public static final int OPERATION_ADDED = 5;

     /**
      * OPERATION_CHANGED indicates that an operation has changed in some way
      * since it was added to the operations history.
      *
      * (value is 6).
      */
     public static final int OPERATION_CHANGED = 6;

     /**
      * OPERATION_NOT_OK indicates that an operation was attempted and not
      * successful. Listeners typically use this when they have prepared for an
      * execute, undo, or redo, and need to know that the operation did not
      * successfully complete. For example, listeners that turn redraw off before
      * an operation is undone would turn redraw on when the operation completes,
      * or when this notification is received, since there will be no
      * notification of the completion.
      *
      * (value is 7).
      */
     public static final int OPERATION_NOT_OK = 7;

     /**
      * OPERATION_REMOVED indicates an operation was removed from the history.
      * Listeners typically remove any record of the operation that they may have
      * kept in their own state. The operation has been disposed by the time
      * listeners receive this notification.
      *
      * (value is 8).
      */
     public static final int OPERATION_REMOVED = 8;

     /**
      * REDONE indicates that an operation was redone. Listeners can take
      * appropriate action, such as revealing any relevant state in the UI.
      *
      * (value is 9).
      */
     public static final int REDONE = 9;

     /**
      * UNDONE indicates that an operation was undone. Listeners can take
      * appropriate action, such as revealing any relevant state in the UI.
      *
      * (value is 10).
      */
     public static final int UNDONE = 10;

     private int code = 0;

     private IOperationHistory history;

     private IUndoableOperation operation;

     /* @since 3.2 */
     private IStatus status;

     /**
      * Construct an event for the specified operation history.
      *
      * @param code
      * the event code to be used.
      * @param history
      * the history triggering the event.
      * @param operation
      * the operation involved in the event.
      */
     public OperationHistoryEvent(int code, IOperationHistory history,
             IUndoableOperation operation) {
         this(code, history, operation, null);
     }

     /**
      * Construct an event for the specified operation history.
      *
      * @param code
      * the event code to be used.
      * @param history
      * the history triggering the event.
      * @param operation
      * the operation involved in the event.
      * @param status
      * the status associated with the event, or null if no status is
      * available.
      *
      * @since 3.2
      */
     public OperationHistoryEvent(int code, IOperationHistory history,
             IUndoableOperation operation, IStatus status) {
         if (history == null) {
             throw new NullPointerException ();
         }
         if (operation == null) {
             throw new NullPointerException ();
         }
         this.code = code;
         this.history = history;
         this.operation = operation;
         this.status = status;
     }

     /**
      * Return the type of event that is occurring.
      *
      * @return the type code indicating the type of event.
      */
     public int getEventType() {
         return code;
     }

     /**
      * Return the operation history that triggered this event.
      *
      * @return the operation history
      */

     public IOperationHistory getHistory() {
         return history;
     }

     /**
      * Return the operation associated with this event.
      *
      * @return the operation
      */

     public IUndoableOperation getOperation() {
         return operation;
     }

     /**
      * Return the status associated with this event.
      *
      * @return the status associated with this event. The status may be null.
      *
      * @since 3.2
      */

     public IStatus getStatus() {
         return status;
     }

 }

